Methods and apparatus to detect content skipping by a consumer of a recorded program

ABSTRACT

Methods and apparatus to detect content skipping by a consumer of a recorded program are disclosed. In a disclosed method, a plurality of recording times of sections of a recorded program are stored in association with playback times of the recorded program. Playback intervals between sequential pairs of the playback times are compared with corresponding recording intervals between sequential pairs of the recording times to determine if any portion of the recorded program was not played back in real time.

FIELD OF THE DISCLOSURE

[0001] This disclosure relates generally to audience measurement, and,more particularly, to methods and apparatus to detect content skippingby a consumer of a recorded program.

BACKGROUND

[0002] Companies that rely on broadcast video and/or audio programs forrevenue, such as advertisers, television networks and content providers,wish to know the size and demographic composition of the audience(s)that consume their program(s). Audience measurement companies addressthis need by measuring the demographic composition of a set ofstatistically selected households and the program consumption habits ofthe member(s) of those households. For example, audience measurementcompanies may collect viewing data on a selected household by monitoringthe content displayed on that household's television(s) and byidentifying which household member(s) are watching that content.

[0003] Traditionally, broadcast programs have been consumed at the timeof broadcast. Therefore, it was safe to assume that audience membersusing an information presenting device such as a television or radioconsumed the entire broadcast stream during the period in which theinformation presenting device was in use. Recently, however, recordingdevices such as audio cassette players, video cassette recorders(VCR's), set top boxes, digital video recorders, and personal videorecorders, such as SonicBlue's ReplayTV®, TiVo® and other devices thatpermit content to be recorded and replayed in accordance with thedesires of the audience members have become commonplace. These deviceshave increased the audience members' ability to time shift theconsumption of broadcast programs (i.e., to record a program at the timeof broadcast and consume that same program at a later time that suitsthe consumer). This ability to time shift has also provided the consumerwith enhanced power to consume only selected portions of broadcastprograms by, for example, skipping or fast-forwarding through portionsof recorded content. Some consumers have used this enhanced ability toavoid viewing advertising commercials or other portions of the broadcastprogram.

BRIEF DESCRIPTION OF THE DRAWINGS

[0004]FIG. 1 is a schematic illustration of an example system to developaudience measurement statistics.

[0005]FIG. 2 is a schematic illustration of an example apparatus todetect content skipping by a consumer of a recorded program.

[0006]FIGS. 3A-3C illustrate example log entry data structures that maybe created by the apparatus of FIG. 2.

[0007]FIG. 4 illustrates another example log entry data structure thatmay be created by the apparatus of FIG. 2.

[0008]FIG. 5 is an example chart identifying example segments, segmentstart times, and segment end times for an example program.

[0009]FIG. 6 is an example chart that may be developed by the apparatusof FIG. 2 to record fast forwarded and/or skipped segments of a recordedprogram and rewound/replayed segments of the recorded program.

[0010]FIG. 7 is a flowchart representative of example machine readableinstructions that may be executed by the digital recording device ofFIG. 1 to determine if a data logging device is coupled thereto.

[0011]FIG. 8 is a flowchart representative of example machine readableinstructions that may be executed by the data logging device of FIG. 1to advise the digital recording device of its presence.

[0012]FIG. 9 is a flowchart representative of example machine readableinstructions that may be executed to implement the apparatus of FIG. 2.

[0013]FIG. 10 is a flowchart representative of additional examplemachine readable instructions that may be executed to implement theapparatus of FIG. 2.

[0014]FIG. 11 is a flowchart representative of more example machinereadable instructions that may be executed to implement the apparatus ofFIG. 2.

[0015]FIGS. 12A-12C are a flowchart representative of additional examplemachine readable instructions that may be executed to implement theapparatus of FIG. 2.

[0016]FIGS. 13A-13B are a flowchart representative of still more examplemachine readable instructions that may be executed to implement theapparatus of FIG. 2.

[0017]FIG. 14 is a flowchart representative of still more examplemachine readable instructions that may be executed to implement theapparatus of FIG. 2.

[0018]FIG. 15 is a schematic illustration of an example device that maybe used to execute the instructions represented by the flowcharts ofFIGS. 7-14 to implement the apparatus of FIG. 2.

DETAILED DESCRIPTION

[0019]FIG. 1 is a schematic illustration of an example system to developaudience measurement statistics. In the illustrated example, a centraldata collection office 10 is connected to a plurality of statisticallyselected households 12, 14, 16 via one or more public and/or privatenetworks 18. The monitored home sites 12, 14, 16 are provided withsensors and/or other passive and/or active data collection engines togather data identifying the broadcast programs consumed by the membersof the monitored households 12, 14, 16, and the household members thatconsumed those programs. The data collected in the monitored home sites12, 14, 16 is exported periodically or continuously to the centraloffice 10 via the network 18. The data collection office 10 includes oneor more computers that analyze the data received from the monitored homesites 12, 14, 16 to develop meaningful audience measurement statisticssuch as, for example, television ratings, audience share measurements,etc. The network 18 can be implemented by any desired network such as,for example, the Internet, the public switched telephone network, awireless connection, dedicated connections, etc.

[0020] In the illustrated example, the home sites 12, 14, 16 receivevideo and/or audio programs broadcast from one or more broadcastingsystems 20. Although FIG. 1 schematically illustrates the broadcastingsystems 20 by a radio tower, persons of ordinary skill in the art willreadily appreciate that the broadcasting systems may be implemented byone or more of a terrestrial broadcasting system, a cable broadcastingsystem, a satellite broadcasting system, the Internet, or any otherbroadcasting system.

[0021] The broadcast programs may include primary content (e.g.,entertainment, informational and/or educational content such as movies,television network programs, sporting events, news, etc.) and may alsoinclude secondary content (e.g., commercials) interspersed within theprimary content. It is frequently the case that the primary content ismore desirable to consumers then the secondary content, but this is notalways the case (e.g., commercials (i.e., secondary content) during theNFL Superbowl are sometimes of greater interest than the football game(i.e., the primary content)). For simplicity of discussion, in thefollowing it will be assumed that the broadcast program contains atelevision program (i.e., primary content) interspersed with commercials(i.e., secondary content) advertising products of a sponsor of thetelevision program.

[0022] The home sites 12, 14, 16 may include any number of informationpresenting devices 22 such as a television, a computer, a radio, astereo, an Internet appliance, etc. The home sites 12, 14, 16 may alsoinclude one or more recording devices such as an analog recording device(e.g., a magnetic tape recording device for recording audio programsand/or a video cassette recorder (VCR)), and/or a digital recordingdevice 24 such as a set top box, a digital video recorder, a personalvideo recorder, a computer, etc. The home site 12, 14, 16 may also beprovided with a data logging device 26 which is coupled to the digitalrecording device to collect, record and/or analyze data reflecting usageof the digital recording device 24. The data collected and/or analyzedby the data logging device 26 may be periodically exported to thecentral office 10 via the network 18 for further analysis and/ordistribution. The data exportation may be performed at regularlyscheduled time intervals and/or may be triggered by predeterminedevents.

[0023] If a digital or personal video recorder 24 is present in the homesite 12, 14, 16, the home site 12, 14, 16 may be connected to one ormore schedule warehouses 28 via one or more public and/or privatenetworks 18. In the illustrated example, the schedule warehouse 28stores media schedules of broadcast programming for use by digitaland/or personal video recorders 24. The media schedules stored in theschedule warehouse 28 may be compiled from information provided by anumber of sources. For example, they may be developed from informationprovided by broadcasters and/or content providers. The media schedulesmay include, among other things, the titles of programs to be broadcast,the scheduled broadcast times for the programs, the broadcast channelsthat are to carry the scheduled programs at the scheduled times, and theidentities of the networks that intend to broadcast the programs. Someof the information present in the media schedules may not be provided tothe digital/personal video recorders 24, but may instead be supplied toaudience measurement companies (e.g., the central office 10) to assistin computing ratings and/or audience demographics information. Thus, asshown in FIG. 1, the central office 10 may also be coupled to theschedule warehouse 28 via the network 18.

[0024] On a periodic basis, the digital/personal video recorders 24retrieve media schedule(s), or portion(s) thereof, from the schedulewarehouse 28 via the network 18. The retrieved schedules are stored in alocal memory of the digital and/or personal video recorder 24 for use inselecting and recording programs of interest. In the personal videorecorder context, the media schedules may include data that enables thepersonal video recorder 24 to select and store programs that may be ofinterest to the members of the household 12, 14, 16 based on priorviewing habits and/or otherwise identified interests of those members.

[0025]FIG. 2 is a schematic illustration of an example apparatus 50 todetect portions of a recorded program that were not played back in realtime (e.g., that were skipped, fast forwarded, paused, and/or rewound).As explained in further detail below, the example apparatus 50 of FIG. 2may be implemented by one or more of the digital recording device 24,the data logging device 26, and/or the central office 10. The apparatus50 is equipped to record and analyze data reflecting usage of, forexample, a digital recording device 24 in a home site 12, 14, 16.

[0026] For the purpose of logging recording or presentation times of abroadcast program recorded at a home site 12, 14, 16, the apparatus 50is provided with a time stamper 52. The time stamper 52 records aplurality of sequential times in association with the recorded program.In particular, the time stamper 52 records the times at which varioussections of a received broadcast program are received and/or stored in amemory 54 of, for example, a digital recording device 24. For example,if the digital recording device 24 is implemented by a digital/personalvideo recorder such as the TiVo® video recorder, the recorded programmay be processed in accordance with a modified version of the MPEG-2standard. In such an example, the broadcast program received by thedigital video recorder may be compressed and stored as two datastreams,namely, an audio datastream and a video datastream. Each of thedatastreams contains a series of data packets. Each of the packetsincludes a header and a payload. The header contains a number of fieldsto store information about the associated content of the packet and/orthe relationship of the packet to other packets in the datastream (e.g.,a packet sequence number). The payload section of the packet stores theprogram content (e.g., a section of the audio and/or video content ofthe broadcast program). The time stamper 52 writes the time at which thecorresponding payload was recorded by the digital/personal videorecorder 24 in a field of the header of the packet. In the example ofthe TiVo® digital/personal video recorder, the time stamps provided bythe time stamper 52 are presentation times (e.g., the times at which thecorresponding packets were received and/or stored by the TiVo® product)and are intended for use in synchronizing the packets of the audiodatastream and the packets of the video datastream during playback ofthe recorded program.

[0027] For the purpose of recording the playback rate of the recordedprogram, the apparatus 50 is further provided with a presentation timeretriever 56. When the recorded program is played back from the memory54 (which may be within seconds or minutes of receipt of the broadcastprogram by the digital recording device 24 if the consumer is “live”viewing the same, or may be hours, days, weeks, months or longer afterreceipt of the broadcast program by the digital recording device 24),the presentation time retriever 56 retrieves the recording/presentationtimes of some or all of the sections of the program being played backand stores those recording times in association with the playback timeof the corresponding sections of the program. In other words, as theprogram is played back, the presentation time retriever 56 periodicallycreates a running list of log entry data structures 58 such as thoseshown in FIGS. 3A-3C. The log entry data structures 58 are preferablycreated and populated at evenly spaced intervals of real time. Inparticular, each log entry data structure 58 is preferably created atsubstantially the time that a corresponding section of the recordedprogram is being played.

[0028] Each log entry 58 may include a playback date field 60 to storedata representative of the playback date (in this example, formatted asMM/DD/YYYY for month/day/year) of a corresponding section of therecorded program, a playback time field 62 to store data representativeof the playback time (in this example, formatted as HH:MM:SS.mmm forhour/minute/second/millisecond) of the corresponding section of theprogram being played, a recording date field 64 to store datarepresentative of the recording date (in this example, formatted asMM//DD//YYYY) of the section of the recorded program being played, and arecording time field 66 to store data representative of the recordingtime (in this example, formatted as HH:MM:SS.mmm) of that same sectionof the program. In the example of the TiVo® video recorder, thepresentation time retriever retrieves the presentation date/time fromthe header(s) of the packet(s) currently being played. The presentationtime retriever 56 then respectively stores the retrieved presentationdate/time in the recording date field 64 and recording time field 66 ofa log entry data structure 58 to associate that data with the playbacktime of the corresponding packet(s). Additionally, the presentation timeretriever 56 may store a current date and time in the playback datefield 60 and the playback time field 62 of that same log entry datastructure 58.

[0029] The presentation time retriever 56 may also retrieve a programidentifier from the packet header of the section of the recorded programcurrently being played back and store that identifier in one or moreprogram identification fields 68. The program identifier may be any formof information that identifies the program being played back (e.g., aprogram name, a program identification number, etc.), and/or the stationthat broadcast the program (e.g., a broadcast channel number, a stationname, or a standardized station identifier). In the example of FIGS.3A-3C, the program identification field 68 contains a universal programidentifier. As is know to persons or ordinary skill in the art, auniversal program identifier is a program code that identifies a programbased on a pre-defined, standardized code arrangement.

[0030] In the example of FIG. 2, the playback dates and times stored bythe presentation time retriever 56 are provided by the time stamper 52.However, persons of ordinary skill in the art will appreciate that theplayback dates and times may alternatively be developed by thepresentation time retriever 56 and/or by a clock separate from the timestamper 52. Irrespective of their source, the playback times stored bythe presentation time retriever 56 preferably correspond to real timeand are evenly spaced. The playback spacing or intervals between theplayback times/log entry data structures 58 are a matter of designchoice. However, persons of ordinary skill in the art will appreciatethat shorter intervals between the recorded playback times/log entrydata structures 58 (i.e., the more playback times recorded, the fewerpackets that are played without logging their recording times),translate into more accurate identification of portions of the recordedprogram that were not played back in real time, and that shorterplayback intervals also translate into higher data collection volumeand, thus, more severe memory resource demands. In the illustratedexample, the playback intervals are 2.7 seconds long (i.e., a log entrydata structure 58 is created every 2.7 seconds). Although the evenlyspaced, equal playback intervals are currently preferred, persons ofordinary skill in the art will appreciate that, instead of beingtriggered by time, the creation of a log entry data structure 58 may betriggered by one or more predetermined events such that the playbackintervals are not equal and/or not evenly spaced in time.

[0031] Persons of ordinary skill in the art will appreciate that, inexamples in which the same playback interval is consistently usedbetween log entries, it is possible to not record the playback time inthe running log because the log entry data structures 58 themselvesinherently provide both an indication of the time lapse between entries(i.e., it is always a consistent value such as, for example, 2.7seconds) and the aggregate amount of time that has passed duringplayback. In other words, because we know that a log entry datastructure 58 recording the playback time of the section of the programcurrently being played back is made every, for example, 2.7 seconds,then we know that the twenty-first log entry (e.g, the log entry datastructure 58 of FIG. 3B) occurred 2.7 seconds after the twentieth logentry (e.g, the log entry data structure 58 of FIG. 3A) without havingto compute a playback interval between those data structures. However,even in cases where the same playback interval is consistently used, itmay be desirable to record the playback times as a mechanism for sortingand/or distinguishing between log entries.

[0032] An alternative example data structure 70 is shown in FIG. 4. Likethe example data structure 58 of FIGS. 3A-3C, the example data structure70 of FIG. 4 includes a playback date field 60, a recording date field64, a recording time field 66, and a program identification field 68.However, unlike the data structure 58 of FIGS. 3A-3C, the data structure70 of FIG. 4 does not contain the playback time field 62 for the reasonsexplained above. The playback date field 60 is retained because it mightbe interesting to learn how much time passed between broadcast andplayback of the recorded program. Similarly, although not used in theexample of FIG. 4, the playback time field 62 is preferably retained inthe data structure 70 because it might be interesting to learn the timeof day at which the playback occurred.

[0033] As shown in FIG. 4, the example log entry data structure 70includes many fields not present in the example data structure 58 ofFIGS. 3A-3B. For instance, the data structure 70 of FIG. 4 includes thefollowing fields: (a) a digital recording device serial number field 71,(b) a sequence number field 72, (c) a tuner identification number field73, (d) a playback mode indicator field 74, (e) an input sourceindicator field 76, (f) a channel number field 78, (g) a network namefield 80, (h) a program name field 82, (i) a universal networkidentifier field 84 and (j) a checksum 86.

[0034] The digital recording device serial number field 71 may containthe serial number of the digital recording device 24 being monitored.The serial number may be a variable-length string (e.g., 12345678) thatuniquely identifies a particular digital recording device 24 such as aset top box, a digital video recorder, and/or a personal video recorder.In monitored households 12, 14, 16 having multiple digital recordingdevices 24, the serial number of the digital recording devices 24 can beused to track the viewing habits within a household 12, 14, 16 on adigital recording device 24 by digital recording device 24 basis.

[0035] The sequence number field 72 may be used to number the datastructures 58, 70 to ensure that they are transmitted, analyzed, and/orprocessed in the correct order. The sequence number field may, forexample, store an unsigned integer. For example, the integer may be avalue in the range of 0-255. When the sequence number reaches 255, thesequence number value is returned to zero to again begin numbering thenext consecutive sequence of data structures 58, 70 from 0-255.

[0036] The tuner number field 73 may contain a variable length stringidentifying the tuner that received the recorded program. For example,the tuner number field 73 may be used to indicate which tuner in adigital recording device 24 having multiple tuners was used to receivethe recorded program.

[0037] The playback mode indicator field 74 may contain playback modeindicator data designating the operational mode of the digital recordingdevice 24 at the time the log file data structure 70 was generated. Inthe illustrated example, the playback mode indicator data may be a codedsuch that the code “1” indicates the device 24 is playing a livebroadcast, the code “2” indicates the device 24 is playing a recordedprogram, the code “3” indicates the device 24 is playing an alternativestream (e.g., a movie trailer which originates from the hard disk of thedevice 24 after being, for example, downloaded via the Internet or atelevision broadcast channel), the code “4” indicates the device 24 isrecording a user selected program, the code “5” indicates the device isrecording a program based on a user profile, the code “6” indicates theuser is accessing a full screen user interface or menu (without audio),and the code “7” indicates that the user is accessing a transparent userinterface screen that overlays a playing program (with audio). If theplayback mode data is code “6”, the broadcast time field 66, the inputsource field 76, the channel number field 78, the station name field 80,and the program name field 82 may be blank in this circumstance and thelog data may not identify the user's activity.

[0038] The input source indicator field 76 may contain a code thatrepresents the input source through which the stored broadcast 120 wasreceived by the digital recording device 24. The input source indicatorfield 76 may designate codes for different input sources to the digitalrecording device 24. For example, the code “RF” may represent a radiofrequency input, the code “SAT1” may represent a first satellite input,the code “SAT2” may represent a second satellite input, the code “COMP”may indicate a composite input, the code “SVID” may represent an S-videoinput and the code “other” may indicate that the recorded program didnot come from a broadcast source, such as when the video was pre-loadedonto a hard disk or the video was delivered through a private channel orbroadband connection. In such circumstances, the video being viewed willnot be identified, and the playback time and channel number fields 62,78 will be left blank.

[0039] The channel number field 78 may contain data indicative of thechannel number of the internal tuner of the digital recording device 24(e.g., a numerical value of 0-99999), data indicative of a channelnumber of an external device such as a television (e.g., a numericalvalue of 0-99999) coupled to the digital recording device 24, dataindicative of a minor channel, the code “manual,” and/or nothing. In theillustrated example, a numeric value stored in the channel number field78 indicates a tuned channel number. However, the stored channel numberin the channel number field 78 may not be the same as the channel numberthat is displayed in the user interface of the digital recording device24 because the user interface may display logical channel numbers thathave been remapped into a single logical channel space.

[0040] In the illustrated example, the channel number field 78 containsdata indicative of the tuned channel of the external device, not thetuned channel of the digital recording device 24, if an external deviceis connected to the RF or satellite input (e.g., on channel 2, 3 or 4).In such circumstances, the input source field 76 indicates that theinput source is “RF.” Therefore, interpretation of the data in thechannel number field 78 is dependent on knowledge of the identity of thedevice connected to the RF input of the digital recording device 24.

[0041] In the illustrated example, the channel number field 78 containsthe code “manual” when the user has requested a manual record from aparticular input source and has specified that the digital recordingdevice 24 should not change channels on the device before starting therecording process. The “manual” channel code may be used with devicesthat cannot be tuned (e.g., camcorders and other devices). The “manual”channel number may also be used with pay-per-view (PPV) events or othertypes of programs where the user is required to perform some specialaction to tune to the desired channel.

[0042] In the illustrated example, the network name field 80 contains avariable-length string of data indicative of the call letters or otherassociated name (e.g. “NBC”) of the broadcasting station that broadcastthe recorded program. Thus, the data in the network name field 80corresponds to the data contained in the channel number field 78. Thestation name may be determined, for example, by comparing the tunedchannel number from the tuned channel field 78 with a program schedulethat has been downloaded from the schedule warehouse 28. If the stationname cannot be determined, then the network name field 80 may be leftblank.

[0043] In the illustrated example, the program name field 82 contains avariable-length string of data representative of the name of therecorded program (e.g. “Friends”). The program name may be determined,for example, by comparing the tuned channel number contained in thechannel number field 78 with a program schedule that has been downloadedfrom the schedule warehouse 28. If the program name cannot bedetermined, then the program name field 82 may be left blank.

[0044] In the illustrated example, the network identifier field 84contains data representative of the network that broadcast the recordedprogram. For example, the data contained in the network identifier field84 may be a universal network identifier that is based on a standardizedarrangement such as the universal broadcast/cable station identifierarrangement. The universal broadcast/cable station identifierarrangement identifies each broadcast/cable station by a unique code.Alternatively, a multi-system operation (MSO) specific code may be used.

[0045] In the illustrated example, the checksum field 84 contains datarepresentative of a computed checksum. The computed checksum may be, forexample, a numerical value based on the number of bits set in thecorresponding data structure 58, 70. Any known software technique forgenerating checksums may be used to calculate and/or check the checksumvalue.

[0046] In order to determine if the audience has played a portion of therecorded program back in something other than real time, the apparatus50 is further provided with an interval detector 90 and a differencedetector 92. The interval detector 90 computes recording intervalsbetween the recording times appearing in successive ones of the logentry data structures 58, 70 developed by the presentation timeretriever 56. The interval detector 90 computes the recording intervalby finding the difference between the recording times appearing insuccessive log entries 58, 70. Persons of ordinary skill in the art willappreciate that, if the recording times appearing in successive logentries 58, 70 are identical, then the recorded program has been pausedfor the duration of the corresponding playback interval (i.e., for theentire duration of the time between the log entries 58, 70 correspondingto the identical recording times). If, on the other hand, the differencebetween the recording times appearing in successive log entries 58, 70has a first sign (e.g., positive), then either the recorded program wasplayed back in real time or the recorded program was played back at arate different than real time (e.g., a portion of the program wasskipped or fast forwarded, or a portion of the program was played backin slow motion or was paused for less than the entire duration of theplayback interval). If instead the difference between the recordingtimes appearing in successive log entries 58, 70 has a second sign(e.g., negative), then the recorded program was rewound.

[0047] The interval detector 90 may also compute playback intervals. Inparticular, the interval detector 90 may optionally calculate thedifference between the playback times stored in successive log entries58, 70 to determine a playback interval corresponding to each pair ofsuccessive log entry data structures 58, 70. However, as explainedabove, if log entries 58, 70 are generated at regular intervals,calculating playback intervals for each pair of successive log datastructures 58, 70 may be dispensed with since the playback intervalswill always be the same. In such circumstances, the same, known constantvalue (e.g., 2.7 seconds) may be used for the playback intervals.

[0048] To determine if any portion(s) of the recorded program have beenplayed at a rate different then real time, the apparatus 50 is providedwith a difference detector 92. The difference detector 92 determines ifa difference exists between any of the recording intervals calculated bythe interval detector 90 and the corresponding playback interval. Inparticular, the difference detector 92 preferably subtracts a valuerepresentative of the recording interval calculated by the intervaldetector 90 from a value representative of the corresponding playbackinterval. (As mentioned above, the corresponding playback interval maybe a value calculated for each pair of data structures 58, 70, or it maybe a constant value based on the understanding that the log entries 58,70 are developed at a constant periodic rate.) If the differencecalculated by the difference detector 92 is zero, then the portion ofthe recorded program corresponding to the recording times stored in thedata structures 58, 70 was played back in real time. If, on the otherhand, the difference calculated by the difference detector 92 isnon-zero, then the portion of the recorded program corresponding to therecording times stored in the data structures 58, 70 was not played backin real time. In particular, if the playback interval is smaller thanthe recording interval such that the difference calculated by thedifference detector 92 is negative, then the portion of the recordedprogram corresponding to the recording times stored in the datastructures 58, 70 was advanced faster than real time (e.g., the portionwas at least partially skipped and/or fast forwarded). Otherwise, if theplayback interval is larger than the recording interval (or therecording interval has a negative sign due to a rewind event) such thatthe difference calculated by the difference detector 92 is positive,then the portion of the recorded program corresponding to the recordingtimes stored in the data structures 58, 70 was at least partially playedin slow motion, rewound, and/or paused for less than the full timeinterval between the corresponding data structures 58, 70.

[0049] To identify the segment(s) in the portion of the recorded programthat were not played back in real time, the apparatus 50 is furtherprovided with a non-real time content identifier 94. The non-real timecontent identifier 94 responds to detection of non-zero differences bythe difference detector 92 by searching a database to determine theidentities of the program segments that were skipped, fast forwarded,and/or rewound. For example, the database may include a plurality ofprogram tables identifying the start times, end times, and names of thesegments of broadcast programs. Each of the program tables may beassociated with a respective broadcast program, and the start and endtimes appearing in those program tables may be normalized as explainedbelow (e.g., such that the start of broadcast time is time zero).

[0050] The program tables may be created by the schedule warehouse 28,the central office 10, content providers, and/or broadcast stations. Anexample program table that may be used by the non-real time contentidentifier 94 to identify the segment(s) of an example recorded programthat were not played in real time is shown in FIG. 5.

[0051] In the example of FIG. 5, the program table includes a namecolumn, a start time column, and an end time column. The name column ispopulated with unique names of the segments of the correspondingprogram. For instance, in the example of FIG. 5, the program includesthe following segments: (a) introduction, (b) commercial 1, (c) content1, (d) commercial 2, (e) content 2, (f) commercial 3, (g) content 3,etc. The start time and end time columns are populated with the startand end times of the corresponding program segments. Preferably thestart times and end times stored in the program table are normalized tothe start of a broadcast interval rather than reflective of actualbroadcast times. For example, the program of FIG. 5 is to run theintroduction segment from time zero (i.e., the start of the broadcastinterval) until time 00:03:30.003 (i.e., for a length of three minutes,thirty seconds, and 3 milliseconds). By way of another example, thesegment entitled “commercial 1” is to start three minutes, thirtyseconds, and 3 milliseconds after the broadcast interval begins.

[0052] Normalized times are preferably used in the program tablesinstead of actual broadcast times because, due to reflections duringtransmission, geographic distances, etc., different home sites 12, 14,16 may receive the same broadcast program at slightly different times.However, all of the relative lengths of the broadcast segments asreceived at the home sites 12, 14, 16 will be the same from site to siteregardless of transmission delays. Therefore, by normalizing the startand end times of the program tables to the start times of the programsthey represent, and by normalizing the start times and the end timesrecorded in the log entry data structures 58, 70 to the overall start(i.e., received) time of the recorded program, the effect oftransmission differences between households can be reduced to therebyallow the non-real time content identifier 94 to use the same table toidentify the program segments that were subjected to non-real timeplayback activity regardless of the location of the monitored home site12, 14, 16 that exhibited the non-real time playback event.

[0053] The non-real time content identifier 94 may begin the searchprocess by locating the program table (if any) corresponding to therecorded program. The located program table may then be searched for thesegment(s) corresponding to the portion of the recorded program whichexperienced something other than real-time playback. For example, thenon-real time content identifier 94 may compare the normalized starttime of the recording interval of the recorded program at issue to thestart times appearing in the program table associated with thecorresponding program (see FIG. 5). Persons of ordinary skill in the artwill readily appreciate that it is unlikely that the normalized starttime of the recording interval that experienced non-real time activitywill correspond exactly to one of the start times appearing in theprogram chart, because the audience member causing the non-real timeeffect is unlikely to send a command to, for example, fast forward,pause, or rewind, at precisely the normalized start time of a programsegment. Instead, it is likely that the normalized start time of therecording interval at issue will fall within a range (e.g., +/−30seconds) around a start time of one of the intervals. Therefore, thenon-real time content identifier 94 is structured to find a matchbetween the start time of the recording interval at issue and a starttime of a segment appearing in the program table, if the correspondingstart times are within some threshold amount (T) of one another.

[0054] Because the portion of the recorded program that experiencednon-real time activity may encompass more than one segment of therecorded program, in addition to searching the program table (see FIG.5) for a corresponding start time, the non-real time content identifier94 also searches the program table associated with the recorded programfor an end time that matches the normalized end time of the recordinginterval that was subjected to non-real time playback. As with the starttime search, it is likely that the normalized end time of the recordinginterval at issue will fall within a range (e.g., +/−30 seconds) aroundan end time of one of the intervals. Therefore, the non-real timecontent identifier 94 is structured to find a match between the end timeof the recording interval at issue and an end time of a segmentappearing in the program table, if the corresponding end times arewithin some threshold amount (T) of one another.

[0055] Once a matching start time and a matching end time are identifiedin the program table, the non-real time content identifier 94 identifiesthe segment(s) corresponding to the substantially matching start and endtimes as the segment(s) of the recorded program that were subjected tonon-real time playback. For instance, in the example of FIG. 5, if thestart time of the recording interval that was subjected to non-real timeactivity substantially matches the start time of the segment entitled“commercial 2,” and the end time of the recording interval substantiallymatches the end time of the segment entitled “commercial 2,” then thenon-real time content identifier 94 identifies the segment “commercial2” as the portion of the recorded program that was subjected to non-realtime playback (e.g., skipped or fast forwarded). As another example, ifthe start time of the recording interval that was subjected to non-realtime activity substantially matches the start time of the segmententitled “commercial 2,” and the end time of the recording intervalsubstantially matches the end time of the segment entitled “content 2,”then the non-real time content identifier 94 identifies both the segmententitled “commercial 2” and the segment entitled “content 2” as theportion of the recorded program that was subjected to non-real timeplayback (e.g., skipped or fast forwarded).

[0056] If the non-real time activity being analyzed by the non-real timecontent identifier 94 was an advancing event (e.g., skipping, fastforwarding, pausing or slow playing), then the recording interval willhave a positive sign and the non-real time content identifier 94 willuse the normalized playback time of the first created data structure inthe pair of data structures 58, 70 associated with the playback intervalas the start time and the normalized playback time of the second createddata structure in the pair of data structures 58, 70 associated with theplayback interval as the end time. If, on the other hand, the non-realtime activity was a rewinding event, then the recording interval willtypically have a negative sign (unless the rewind was very short (e.g.,less than one half the length of the playback interval))and the non-realtime content identifier 94 will use the normalized playback time of thesecond created data structure in the pair of data structures 58, 70associated with the playback interval as the start time and thenormalized playback time of the first created data structure in the pairof data structures 58, 70 associated with the playback interval as theend time. This latter approach enables the non-real time contentidentifier 94 to record the segments of the recorded program encompassedwithin the rewound interval. Persons of ordinary skill in the art willappreciate, however, that, just because the segments were rewound, doesnot mean that all of those segments were watched. Therefore, if any ofthe rewound segments are subjected to further non-real time playback(e.g., rewinding, fast forwarding, pausing, and/or skipping), theapparatus 50 will log that activity for later reconciliation asexplained below.

[0057] Persons of ordinary skill in the art will appreciate thatalternative methods of identifying the segments of the recorded programthat were subjected to non-real time playback activity may alternativelybe employed. For example, rather than requiring a start or end time ofthe recording interval to respectively fall within a range around astart time and end time appearing in the program table, the non-realtime content identifier 94 may alternatively search the program table todetermine if the recording interval overlaps with at least apredetermined portion (e.g., 10%) of one or more of the known intervalsreflected in that table. The non-real time content identifier 94 maythen identify the segment(s) associated with the known interval(s) thatare sufficiently overlapped by the recording interval that experiencednon-real time playback as the segment(s) that were not played back inreal time.

[0058] Irrespective of the methodology employed for determining theidentities of the segments of the recorded program that were subjectedto non-real time playback activity (e.g., fast forwarding, pausing,skipping, and/or rewinding), the non-real time content identifier 94preferably records the determined identities of the segments in arecapture table such as the example recapture table shown in FIG. 6. Inthe example of FIG. 6, the recapture table includes two columns. A firstcolumn is used to store the identities of all segments of the recordedprogram that were advanced in time during the recording interval at arate faster than real time. Thus, the first column stores the identities(in this example, represented by segment numbers), of any segments thatthe non-real time content identifier 94 identifies as having beenskipped and/or fast forwarded. The second column of the recapture tableof FIG. 6 is used to store the identities of all segments of therecorded program that were rewound.

[0059] As mentioned above, a segment of a recorded program that isinitially skipped and/or fast forwarded may later be viewed in real timeif a portion of the recorded program encompassing that segment isrewound. To determine if a portion of the recorded program that waspassed at a rate greater than real time was viewed in real time as aresult of rewinding the recorded program, the apparatus 50 is furtherprovided with a recapture identifier 96. In the illustrated example, therecapture identifier 96 compares the segment names appearing in thefirst column of the recapture table of FIG. 6 with the segment namesappearing in the second column of the recapture table of FIG. 6.Whenever the recapture identifier 96 encounters the same segment name inboth columns, the recapture identifier 96 removes the pair of segmentnames from the table. The segment names remaining in the advanced columnof the recapture table after the recapture identifier 96 has checkedevery entry of the advanced column for a corresponding entry in therewound column, represent the segments that were skipped and/or fastforwarded without being recaptured by a rewind. The segment namesremaining in the rewound column of the recapture table after therecapture identifier 96 has checked every entry of the advanced columnfor a corresponding entry in the rewound column, represent the segmentsthat were rewound and reviewed.

[0060] It must be emphasized that the recapture identifier 96 cancelsone segment name in each column of the recapture table when a match isidentified. Thus, if the same segment name appears twice in the advancedcolumn and once in the rewound column, the recapture identifier 96 willremove one instance of the segment name from the advanced column and theone instance of that segment name from the rewound column, but thesecond instance of the segment name will remain in the advanced column,because the second entry of the segment name in the advanced columnindicates that the segment was again skipped and/or fast forwarded afterthe rewound event. For instance, in the example of FIG. 6, segment “5”was fast forwarded and/or skipped one time and rewound one time suchthat the fast forwarding/skipping event and rewinding event cancel eachother out and, absent other data, segment “5” was played at real timeone time. Therefore, when the recapture identifier 96 processes therecapture table, it will remove both references to segment “5” from therecapture table. As a result, when the processing of the recapture tableis complete, there will be no reference to segment “5” in the recapturetable, thereby indicating that segment “5” was viewed in real time.

[0061] On the other hand, segment “8” appears twice in the advancedcolumn and once in the rewound column because, although it was rewoundonce, it was fast forwarded twice (i.e., it was never played in realtime). Therefore, when the recapture identifier 96 processes therecapture table of FIG. 6, it will remove one instance of the segment“8” from the advanced column and the only instance of segment “8” fromthe rewound column. As a result, when the processing of the recapturetable of FIG. 6 is complete, there will be one reference to segment “8”in the advanced column, but no reference to that segment in the rewoundcolumn, thereby indicating that segment “8” was fast forwarded and/orskipped and not recaptured by a rewind event.

[0062] In another example, segment “7” only appears in the rewoundcolumn of the example recapture table of FIG. 6. As a result, when theprocessing of the recapture table of FIG. 6 is complete, there will beone reference to segment “7” in the rewound column, but no reference tothat segment in the advanced column, thereby indicating that segment “7”was twice viewed in real time.

[0063] Persons of ordinary skill in the art will appreciate that theapparatus 50 may be located in a single device (e.g., the digitalrecording device 24) or distributed across multiple devices. Forinstance, in the example of FIG. 1, the apparatus 50 may be implementedby the digital recording device 24, the data logging device 26, and/orthe central office 10. In a more specific example, the time stamper 52,a portion of the memory 54, and the presentation time retriever 56 areimplemented by the digital recording device 24, and the intervaldetector 90, the difference detector 92, the non-real time contentidentified 94, a portion of the memory 54, and the recapture identifier96 are implemented by the data logging device 26 and/or the centraloffice 10. If the interval detector 90, the difference detector 92, thenon-real time content identified 94 and the recapture identifier 96 areimplemented by the data logging device 26, the processed data entrystructures 50, 78 and recapture table(s) (see FIG. 6) may beperiodically exported to the central office via the network 18 forcompilation with data from other home sites 12, 14, 16 and/or furtheranalysis. If the interval detector 90, the difference detector 92, thenon-real time content identified 94 and the recapture identifier 96 areimplemented by the central office 10, the data logging device 26 may beexcluded or may function as a store and forward repository for the logentry data structures 58, 70.

[0064] Flowcharts representative of example machine readableinstructions for implementing the apparatus 50 of FIG. 2 are shown inFIGS. 7-14. In this example, the machine readable instructions compriseone or more programs for execution by one or more processors such as theprocessor 1012 shown in the example device 1000 discussed below inconnection with FIG. 15. The program(s) may be embodied in softwarestored on a tangible medium such as a CD-ROM, a floppy disk, a harddrive, a digital versatile disk (DVD), or a memory associated with aprocessor, but persons of ordinary skill in the art will readilyappreciate that the entire program(s) and/or parts thereof couldalternatively be executed by a device other than a processor and/orembodied in firmware or dedicated hardware in a well known manner. Forexample, any or all of the time stamper 52, the presentation timeretriever 56, the interval detector 90, the difference detector 92, thenon-real time content identifier 94, and/or the recapture identifier 96could be implemented by software, hardware, and/or firmware. Further,although the example program(s) are described with reference to theflowcharts illustrated in FIGS. 7-14, persons of ordinary skill in theart will readily appreciate that many other methods of implementing theexample apparatus 50 may alternatively be used. For example, the orderof execution of the blocks may be changed, and/or some of the blocksdescribed may be changed, eliminated, or combined.

[0065] The programs of FIGS. 7 and 8 may be used in examples wherein thedata logging device 26 is used to store, analyze and/or forward the logentry data structures 58, 70 output by the digital recording device 24.In such an example, the digital recording device 24 may execute theprogram of FIG. 7 and the data logging device 26 may execute the programof FIG. 8 to enable the digital recording device 24 to determine if thedata logging device 26 is connected and, thus, if logging of useractivity is desired. The digital recording device 24 and the datalogging device 26 may be connected in any desired manner. For example,they may be connected via a serial connection (e.g., a DB-9 connectionor a USB connection).

[0066] Irrespective of how the digital recording device 24 and datalogging device 26 are connected, the program of FIG. 7 begins at block100 where the processor of the digital recording device 24 sets anattempt counter to a maximum value (e.g., 30). The processor of thedigital recording device 24 then send a message to the digital loggingdevice 26 (block 102) to determine if a digital logging device 24 isconnected to its output port (e.g., a DB-9 serial port). If the digitalrecording device 24 receives an acknowledgement signal back from thedata logging device 26 (block 104), control advances to block 114.Otherwise, control advances to block 106.

[0067] Assuming for purposes of discussion that an acknowledgement hasnot been received (block 104), the processor of the digital recordingdevice 24 decrements the attempts counter by one (block 106). If theattempts counter has reached zero (block 108), it is determined that nodata logging device 26 is coupled to the digital recording device 24. Asa result, the logging function of the digital recording device 26 isdisabled such that no usage data is collected and stored in the datastructures 58, 70 (block 110). The program of FIG. 7 then terminates.

[0068] If, on the other hand, the attempts counter has not reached zero(block 108), then control advances to block 112. At block 112, theprocessor of the digital recording device 24 determines if sufficienttime has passed to again try to contact the logging device 26. Whensufficient time has passed (block 112), control returns to block 103where the processor of the digital recording device 24 sends anothermessage to the data logging device 24. Control continues to loop throughblocks 102-112 until the attempt counter reaches zero (block 108) andthe logging function is disabled (block 110), or until anacknowledgement message is received back from an attached data loggingdevice 26 (block 104).

[0069] If an acknowledgement signal is received back from a data loggingdevice (block 104), the processor of the digital recording device 24starts a recording thread as explained below in connection with FIG. 9.

[0070]FIG. 8 illustrates a program that may be executed by the datalogging device 26 at start-up. The program begins at block 120 where theprocessor of the data logging device 26 enters a loop wherein the datalogging device 26 waits to receive data from the digital recordingdevice 24. If a data signal is received (block 120), the processor ofthe data logging device 26 waits a predetermined length of time (block122) and then sends an acknowledgement signal back to the digitalrecording device 24 (block 124). (The returned acknowledgement signal isthe signal the digital recording device is seeking at block 104 of FIG.1.) The data logging device 26 then stores, analyzes, and/or forwardsthe data structures 58, 70 received from the digital recording device 24as explained in further detail below.

[0071] From the foregoing, persons of ordinary skill in the art willappreciate that the example of FIGS. 7-8 employs a handshaking methodwherein the presence or absence of an acknowledgement signal is used todetect if a data logging device 26 is coupled to a digital recordingdevice 24. In the example of FIGS. 7-8, if no data logging device 26 isattached, the digital recording device 24 will not log data reflectingits usage pattern. In the illustrated example, once the data loggingfunctionality is disabled, there will be no attempt to re-enable thesame unless a re-set or power-up event of the digital recording device24 occurs.

[0072] Persons of ordinary skill in the art will further appreciate thatthe programs of FIGS. 7-8 may be eliminated in examples wherein thedigital recording device 24 alone implements the apparatus 50 and/or inexamples in which the digital recording device 24 implements theapparatus 50 in cooperation with the central office 10 without the useof a data logging device 26. Although as explained above, there arenumerous ways to implement the functionality of the apparatus 50, forsimplicity of explanation, the discussion of FIGS. 9-14 below assumesthe presence of a data logging device 26 wherein the data logging device26 implements the interval detector 90, the difference detector 92, thenon-real time content identified 94 and the recapture identifier 96, andthe data logging device periodically exports the data it collects andanalyzes to the central office 10 for compilation with data from othermonitored sites 12, 14.

[0073] Assuming that the digital recording device 24 has initiated therecord thread (block 114, FIG. 7), the record thread begins by enteringa loop wherein it awaits the receipt of program data by the digitalrecording device 24 (block 200). Program data may be received from manysources. For example, it may be tuned data developed by a tuner of thedigital recording device 24, it may be data received by the digitalrecording device 24 from an external device via, for example, an RFinput, a Satellite input, or an S-video input, etc. When program data isreceived (block 200), the digital recording device 24 packetizes thereceived program data into one or more datastreams (block 202). Forexample, if the digital recording device 24 is a TiVo® digital/personalvideo recorder, the received program data may be packetized into astream of video packets and a stream of audio packets. The time stamper52 then writes the present time into one or more headers of the packetsin the datastream(s) (block 204). The recording of these presentationtimes in the datastream(s) may be intended, for example, for use insynchronizing a video datastream and an audio datastream, but is alsoused for identifying non-real time activity as explained further below.

[0074] Other data may also be written into the datastream(s) (block206). For example, any or all of a program identifier, a digitalrecording device serial number, the input port from which the data wasreceived, the channel number, the station name, the program name, andthe station identifier associated with the program being recorded may berecorded in the datastream(s). After the packet(s) are completelypopulated (block 206), they are stored in the memory 54 (block 208).

[0075] The digital recording device 24 then determines if a playbackcommand (e.g., play, rewind, pause, fast forward, etc.) has beenreceived (block 210). If so, the digital recording device 24 initiatesthe playback thread (block 212) as explained below in connection withFIG. 10. Otherwise, control advances to block 214.

[0076] At block 214, the digital recording device 24 determines if thelogging functionality has been initiated. If so, the digital recordingdevice 24 initiates the export thread as explained below in connectionwith FIG. 11 (block 216). Otherwise, if the logging functionality hasnot been initiated (block 214), control returns to block 200 withoutpassing through block 216.

[0077] Persons of ordinary skill in the art will appreciate thattypically only one playback thread and one export thread will execute ata given time.

[0078] Assuming a playback thread has been initiated, at block 220 ofFIG. 10, the digital recording device 24 retrieves the packet(s) of oneor more datastream(s) corresponding to the program specified by the userfrom the memory 54 for playback in accordance with the user'sinstructions. The digital recording device 24 then determines if thelogging functionality is enabled by, for example, checking a flag set atblock 110 of FIG. 7 (block 222). If the logging functionality is notenabled (block 206), control advances to block 232. Otherwise controlproceeds to block 224.

[0079] Assuming for purposes of discussion that the loggingfunctionality is enabled (block 222), the digital recording device 24creates a log entry data structure (e.g., data structure 58 or datastructure 70) (block 224). The time stamper 52 then writes one or moreof the current time and date into the playback fields 60, 62 of the datastructure 58, 70 (block 226). Control then advances to block 228.

[0080] At block 228, the presentation time retriever 56 extracts thepresentation/recording time from the packet(s) currently being played(block 228). Other data may also be extracted from the packet(s) (block228). For example, any or all of a program identifier, a digitalrecording device serial number, the input port from which the data wasreceived, the channel number, the station name, the program name, andthe station identifier associated with the recorded program may beextracted from the packet(s) that are currently being played.

[0081] The data extracted by the presentation time retriever 56 iswritten into the corresponding field of the log entry data structure 58,70 such that the extracted data is associated with the playback time ofthe corresponding packet(s) (block 230). Control then advances to block232.

[0082] Irrespective of whether control reaches block 232 from block 222or block 230, at block 232 the digital recording device 24 outputs thepacket(s) to an information presenting device such as a television. Thedigital recording device 24 then determines if all of the packets of therecorded program requested by the user of the digital recording device24 have been output (block 234). If so, the playback thread terminates.Otherwise, control returns to block 220.

[0083] Control continues to loop through blocks 220-234 until all of thepacket(s) associated with the recorded program requested by the consumerhave been output (block 234). The playback thread then terminates asexplained above.

[0084] Assuming the export thread has been initiated, at block 240 ofFIG. 11, the digital recording device 24 determines if a minimuminterval of time has passed since the last message containing a logentry data structure was exported to, for example, the data loggingdevice 26. If not, control remains at block 240 until that time intervalhas passed. The digital recording device 24 then attempts to export thenext message containing a log entry data structure 58, 70 (block 242).The message sent at block 242 is queued in a low priority thread suchthat it does not impact the perceptible usage of the device 24 by theconsumer. The queue may contain multiple messages. The messagescontained in the queue may be sent in the order they were created or outof order. In the case where out or order exporting is possible, sequencenumbers may be used to re-order the messages upon receipt.

[0085] At block 244, the digital recording device 24 determines if themessage is still pending in the queue. If the message has been sent,control returns to block 240 to await the time to send the next messagecontaining the next log entry data structure 58, 70. Otherwise, thedigital recording device 24 determines if the maximum time interval(e.g., 30 seconds) between exporting of messages containing log entrydata structures has passed (block 246). If that allotted time has notpassed (block 246), control returns to block 244. Otherwise, if themaximum permitted delay in transmitting a queued message has passed(block 246), the message containing the excessively delayed messagecontaining the log entry data structure is converted to a high prioritymessage and immediately exported (block 248). Control then returns toblock 240.

[0086] Control continues to loop through blocks 240-248 until the exportthread is terminated by, for example, turning off the digital recordingdevice 24. Thus, once the export thread is initiated (block 216, FIG.9), it will continue to export messages containing log entry datastructures 58, 70 until operation of the digital recording device 24 isinterrupted. Since, in the illustrated example, a data structure 58, 70is created every 2.7 seconds, the digital recording device 24 may exportup to 32,000 data structures 58, 70 per day describing what the user isviewing via the digital recording device 24 at any given time. Ofcourse, asynchronous models which create data structures based ondetected events in addition to or in place of the expiration of set timeintervals would export different quantities of data structures.

[0087] An example program for implementing the interval detector 90 andthe difference detector 92 is shown in FIGS. 12A-12C. The exampleprogram of FIGS. 12A-12C may be executed, for example, by the datalogging device 26 and/or the central office 10. Alternatively, theprogram of FIGS. 12A-12C could be executed by the digital recordingdevice 24.

[0088] The program of FIGS. 7A-7C begins at block 270 where the intervaldetector 90 retrieves a pair of contiguous log entry data structures 58,70. The interval detector 90 then calculates a presentation timedifference (i.e., a recording time interval) by subtracting thepresentation time value recorded in the older data structure 58, 70 fromthe presentation time value recorded in the newer data structure 58, 70(block 272). The interval detector 90 may then calculate a real timedifference (i.e., a playback interval) between the data structures 58,70 by subtracting the playback time value recorded in the older datastructure 58, 70 from the playback time value recorded in the newer datastructure 58, 70 (block 274). As explained above, block 272 may beeliminated if the log entry data structures 58, 70 are created at aconstant, fixed interval so that the real time difference between logentry data structures 58, 70 is always a known constant.

[0089] After the recording time interval and playback time intervals areobtained (blocks 272 & 274), the difference detector 92 determines ifthe presentation time difference (i.e., the recording interval) betweenthe pair of log entry data structures 58, 70 is zero (block 276). If so,the recorded program was paused for the entire playback interval betweenthe data structures (block 278), that fact is logged and controladvances to block 298 (FIG. 12B). At block 298, the interval detector 90determines is the last pair of log entry data structures 58, 70 havebeen analyzed. If not, control returns to block 270 (FIG. 12A).Otherwise, control advances to block 300 where the recapture identifier96 is invoked as explained below in connection with FIG. 14.

[0090] If the presentation time difference (i.e., the recordinginterval) between the pair of log entry data structures 58, 70 is notzero (block 276), a full interval pause did not occur and controladvances to block 280.

[0091] At block 280, the difference detector 92 determines if therecording interval is less than the playback interval. If the recordinginterval (i.e, the presentation time difference) is smaller than theplayback interval (i.e., the real time interval) between the datastructures 58, 70 (block 280), the corresponding portion of the recordedprogram has been paused or rewound and control advances to block 286. Ifthe presentation time difference is a positive value, then a brief pauseevent or slow motion playback occurred, the same is noted, and controlreturns to block 298 of FIG. 12B.

[0092] If the presentation time difference is negative, a rewind eventhas occurred and control advances to block 288. At block 288, thenon-real time content identifier 94 is invoked. As explained below inconnection with FIGS. 13A-13B, the non-real time content identifier 94returns an identification of the segment(s) of the recorded program thatwere rewound. The returned segment names are written in the rewoundcolumn of a recapture table such as that shown in FIG. 6 (block 290).Control then advances to block 298 of FIG. 12B as explained above.

[0093] If the recording interval is not less than the playback interval(block 280, FIG. 12A), control advances to block 292 of FIG. 12B. Atblock 292, the difference detector 92 determines if the recordinginterval is equal to the playback interval. If the recording interval(i.e, the presentation time difference) is not equal to the playbackinterval (i.e., the real time interval) between the data structures 58,70 (block 292), the corresponding portion of the recorded program hasbeen skipped and/or fast forwarded and control advances to block 294. Atblock 294, the non-real time content identifier 94 is invoked. Asexplained below in connection with FIGS. 13A-13B, the non-real timecontent identifier 94 returns an identification of the segment(s) of therecorded program that were skipped and/or fast forwarded. The returnedsegment names are written in the advanced column of a table such as thatshown in FIG. 6 (block 296). Control then advances to block 298.

[0094] If the recording interval (i.e, the presentation time difference)is equal to the playback interval (i.e., the real time interval) betweenthe data structures 58, 70 (block 292), the corresponding portion of therecorded program has not been skipped and/or fast forwarded and controladvances directly to block 298.

[0095] Control continues to loop through blocks 270-298 until every pairof log entry data structures 58, 70 in a block of such data (e.g., ablock of data corresponding to 30 minutes of monitoring) have beenanalyzed for non-real time activity (block 298). When that occurs, therecapture identifier 96 is invoked to operate on that block of data(block 300). After the recapture identifier 96 analyzes the data asexplained below in connection with FIG. 14, control returns to block 270to start the analysis of the next block of data.

[0096] As mentioned above, the non-real time content identifier 94 isinvoked at block 288 of FIG. 12C and block 294 of FIG. 12B. Theoperation of the non-real time content identifier 94 will now beexplained in connection with FIGS. 13A-13B. The identify non-real timecontent routine begins at block 312 when the non-real time contentidentifier 94 retrieves the identity of the recorded program from one ofthe corresponding log entry data structures 58, 70 and a program tablesuch as the example program table shown in FIG. 5 for the recordedprogram from a database of program tables. The non-real time contentidentifier 94 then retrieves the recording times for the portion of therecorded program that experienced non-real time activity from the logentry data structures 58, 70 (block 314). The retrieved times are thennormalized by, for example, subtracting the start time of the recordedprogram as recorded in the log entry data structures 58, 70 from therecording times retrieved from the log entry data structures 58, 70(block 316).

[0097] Once the retrieved times are normalized (block 316), a pointer isset to point to the first segment identified in the program tablecorresponding to the recorded program (see FIG. 5) and the start and endtimes of the pointed to interval are retrieved from the program table(block 318). The non-real time content identifier 94 then determines ifthe start time for the interval being identified is substantially equalto (e.g., falls within some range of) the start time of the intervalpointed to in the program table (block 320). If not, the pointer ismoved to point to the next segment in the program table (block 322), andcontrol returns to block 320. Control continues to loop through blocks320-322 until a match between the start time for the interval beingidentified and the start time of the interval pointed to in the programtable occurs (block 320). When a match occurs, the segment correspondingto the matched start time is recorded and control then advances to block324 (FIG. 13B).

[0098] At block 324, the non-real time content identifier 94 determinesif the end time for the interval being identified is substantially equalto (e.g., falls within some range of) the end time of the intervalpointed to in the program table. If not, the pointer is moved to pointto the next segment in the program table (block 326), and controlreturns to block 324. Control continues to loop through blocks 324-326until a substantial match between the end time for the interval beingidentified and the end time of the interval pointed to in the programtable occurs (block 324). When a match occurs, the segment correspondingto the matched end time is recorded and control then advances to block328.

[0099] If the non-real time content identifier 94 has recorded a segmentcorresponding to the start time of the portion of the recorded programthat experienced non-real time activity and a segment corresponding tothe end time of the portion of the recorded program that experiencednon-real time activity (block 328), the non-real time content identifier94 records the identities of the segment corresponding to the starttime, the segment corresponding to the end time, and any segment(s)falling between the start time and the end time of the portion of therecorded program that experienced non-real time activity. Persons ofordinary skill in the art will appreciate that if the start and endtimes identified at block 320 and 324 correspond to a single segment,then only one segment is recorded at block 330. With the segmentidentity(ies) recorded (block 330), control returns to the calling block(i.e., block 288 or block 294).

[0100] If the non-real time content identifier 94 has not recorded asegment corresponding to the start time of the portion of the recordedprogram that experienced non-real time activity and a segmentcorresponding to the end time of the portion of the recorded programthat experienced non-real time activity (block 328), the non-real timecontent identifier 94 records the identity of the portion of therecorded program that experienced non-real time activity as “identifiedsegment” (block 332). Control then returns to the calling block (i.e.,block 288 or block 294).

[0101] It will be appreciated by persons of ordinary skill in the artthat the start time of the portion of the recorded program employed atblock 320 is the normalized start time retrieved from the earliercreated log entry data structure 58, 70 if the non-real time contentidentifier 94 is invoked from block 294 of FIG. 12B (i.e., a skipped andor fast forwarded portion is being identified). Similarly, the end timeof the portion of the recorded program employed at block 324 is thenormalized end time retrieved from the later created log entry datastructure 58, 70 if the non-real time content identifier 94 is invokedfrom block 294 of FIG. 12B (i.e., a skipped and or fast forwardedportion is being identified).

[0102] Conversely, it will be appreciated by persons of ordinary skillin the art that the start time of the portion of the recorded programemployed at block 320 is the normalized start time retrieved from thelater created log entry data structure 58, 70 if the non-real timecontent identifier 94 is invoked from block 288 of FIG. 12C (i.e., arewound portion is being identified). Similarly, the end time of theportion of the recorded program employed at block 324 is the normalizedend time retrieved from the earlier created log entry data structure 58,70 if the non-real time content identifier 94 is invoked from block 288of FIG. 12C (i.e., a rewound portion is being identified).

[0103] As mentioned above, the recapture identifier 96 is invoked atblock 300 of FIG. 12B. The operation of the recapture identifier 96 willnow be explained in connection with FIG. 14. The recapture routinebegins at block 350 when the recapture identifier 96 determines if thereare any rewound segments identified in the recapture table (e.g., therecapture table of FIG. 6). If there are no rewound segments in therecapture table (block 350), the recapture routine immediatelyterminates and control returns to block 270 of FIG. 12A. If there arerewound segments in the recapture table (block 350), the recaptureidentifier 96 determines if there are any fast forwarded and/or skippedsegments identified in the recapture table (block 352). If there are nofast forwarded and/or skipped segments in the recapture table (block352), the recapture routine immediately terminates and control returnsto block 270 of FIG. 12A. If there are fast forwarded and/or skippedsegments in the recapture table (block 352), control advances to block354.

[0104] At block 354, the recapture identifier 96 retrieves the firstfast forwarded and/or skipped segment from the recapture table. Therecapture identifier 96 then compares the retrieved fast forwardedand/or skipped segment to the segment(s) listed in the recapture tableas rewound segments (block 356). If the retrieved fast forwarded and/orskipped segment appears on the rewound list of the recapture table(block 356), the retrieved segment is deleted from both the advancedlist and the rewound list of the recapture table (block 358) and controladvances to block 360. Otherwise, control advances directly from block356 to block 360.

[0105] At block 360, the recapture identifier 96 determines if everysegment in the advanced segment list of the recapture table has beencompared to the segment(s) appearing in the rewound list of therecapture table. If not, control advances to block 362 where the nextsegment appearing in the advanced list of the recapture table isretrieved. Control then returns to block 356.

[0106] Control continues to loop through blocks 356-360 until everysegment in the advanced list has been compared to the segment(s) in therewound list (block 360). The recapture routine then terminates andcontrol returns to block 270 of FIG. 12A.

[0107]FIG. 15 is a block diagram of an example device 1000 capable ofimplementing the apparatus and methods disclosed herein. In particular,the device 1000 can be, for example, a server, a personal computer, apersonal digital assistant (PDA), an Internet appliance, a DVD player, aCD player, a digital video recorder, a personal video recorder, a settop box, device, an application specific device such as the data loggingdevice 26, or any other type of computing device.

[0108] The system 1000 of the instant example includes a processor 1012.For example, the processor 1012 can be implemented by one or more Intel®microprocessors from the Pentium® family, the Itanium® family or theXScale® family. Of course, other processors from other families are alsoappropriate.

[0109] The processor 1012 is in communication with a main memoryincluding a volatile memory 1014 and a non-volatile memory 1016 via abus 1018. The volatile memory 1014 may be implemented by SynchronousDynamic Random Access Memory (SDRAM), Dynamic Random Access Memory(DRAM), RAMBUS Dynamic Random Access Memory (RDRAM) and/or any othertype of random access memory device. The non-volatile memory 1016 may beimplemented by flash memory and/or any other desired type of memorydevice. Access to the main memory 1014, 1016 is typically controlled bya memory controller (not shown) in a conventional manner.

[0110] The device 1000 also includes a conventional interface circuit1020. The interface circuit 1020 may be implemented by any type of wellknown interface standard, such as an Ethernet interface, a universalserial bus (USB), a high performance serial bus such as an IEEE 1394 busor firewire, and/or a third generation input/output (3GIO) interface.

[0111] One or more input devices 1022 may be connected to the interfacecircuit 1020. The input device(s) 1022 permit a user to enter data andcommands into the processor 1012. The input device(s) can be implementedby, for example, an infrared hand held controller, a keyboard, a mouse,a touchscreen, a track-pad, a trackball, isopoint and/or a voicerecognition system.

[0112] One or more output ports 1024 are also connected to the interfacecircuit 1020. The output ports 1024 can be implemented, for example, byserial ports (e.g., DB-9, USB, etc) or parallel ports.

[0113] The interface circuit 1020 also includes a communication device(e.g., communication device 56) such as a modem or network interfacecard to facilitate exchange of data with external computers via anetwork 1026 (e.g., an Ethernet connection, a digital subscriber line(DSL), a telephone line, coaxial cable, a cellular telephone system,etc.).

[0114] The device 1000 also includes one or more mass storage devices1028 for storing software and data. Examples of such mass storagedevices 1028 include flashcards, jump drives, floppy disk drives, harddrive disks, compact disk drives and digital versatile disk (DVD)drives.

[0115] The device 1000 may also include a tuner 1030 for receivingbroadcast programs and/or an MPEG decoder 1032 for compressing,encoding, decompressing and/or decoding the received programs.

[0116] The device of FIG. 15 may be representative of the digitalrecording device 24 and/or the data logging device 26. The data loggingdevice 26 may be similarly constructed to the digital recording device24, but it would typically not include input device(s) 1022, a tuner1030 or an MPEG decoder 1032.

[0117] Although the above examples focused on video broadcast programsintended for consumption on a visual information presenting device 22(e.g., a television) coupled to a digital recording device 24 such as adigital video recorder, a personal video recorder and/or a set top box,persons of ordinary skill in the art will appreciate that the methodsand apparatus described herein could also be used with broadcastprograms intended for consumption on a purely audio informationpresenting device (e.g., a radio) and/or to analog recording devices(e.g., a cassette recorder and/or a VCR).

[0118] Further, although certain example methods and apparatus have beendescribed herein, the scope of coverage of this patent is not limitedthereto. On the contrary, this patent covers all methods, apparatus andarticles of manufacture fairly falling within the scope of the appendedclaims either literally or under the doctrine of equivalents.

What is claimed is:
 1. A method of detecting portions of a recordedprogram that were not played back in real time comprising: storing aplurality of recording times of sections of the recorded program inassociation with playback times of the recorded program; and comparingplayback intervals between sequential pairs of the playback times withcorresponding recording intervals between sequential pairs of therecording times to determine if any portion of the recorded program wasnot played back in real time.
 2. A method as defined in claim 1 whereinthe plurality of recording times substantially correspond to times atwhich respective sections of the recorded program are recorded by alocal device.
 3. A method as defined in claim 1 further comprisingstoring the recorded program as a plurality of data packets with therecording times stored in headers of the data packets.
 4. A method asdefined in claim 3 wherein each of the recording times is stored inassociation with at least one respective packet.
 5. A method as definedin claim 3 wherein storing the plurality of recording times of sectionsof the recorded program in association with playback times of therecorded program further comprises: retrieving a recording time from aheader of a data packet being played back; and storing the recordingtime in association with one of the playback times.
 6. A method asdefined in claim 1 wherein the playback times substantially correspondto times at which respective sections of the recorded program are playedback by a local device.
 7. A method as defined in claim 1 whereinstoring the plurality of recording times of sections of the recordedprogram in association with playback times of the recorded programcomprises: creating a plurality of log entry data structures; andstoring respective ones of the playback times in respective ones of theplurality of log entry data structures.
 8. A method as defined in claim7 further comprising storing respective ones of the plurality ofrecording times in respective ones of the plurality of log entry datastructures.
 9. A method as defined in claim 1 wherein storing theplurality of recording times of sections of the recorded program inassociation with playback times of the recorded program comprises:creating a plurality of log entry data structures; and storingrespective ones of the recording times in respective ones of theplurality of log entry data structures.
 10. A method as defined in claim1 wherein, if a playback interval is different than a corresponding oneof the recording intervals, then a portion of the recorded program atleast partially corresponding to the recording interval was not playedback in real time.
 11. A method as defined in claim 10 furthercomprising identifying the portion of the recorded program that was notplayed back in real time.
 12. A method as defined in claim 11 whereinidentifying the portion of the recorded program that was not played backin real time comprises: comparing a start time of the recording intervalassociated with the portion of the recorded program that was not playedback in real time to known start times associated with segments of therecorded program; comparing an end time of the recording intervalassociated with the portion of the recorded program that was not playedback in real time to known end times associated with segments of therecorded program; and if the start time of the recording intervalassociated with the portion of the recorded program that was not playedback in real time substantially matches the known start time of a firstsegment, and the end time of the recording interval associated with theportion of the recorded program that was not played back in real timesubstantially matches the known end time of the first segment,identifying the first segment as the portion of the recorded programthat was not played back in real time.
 13. A method as defined in claim12 wherein if the start time of the recording interval associated withthe portion of the recorded program that was not played back in realtime substantially matches the known start time of the first segment,and the end time of the recording interval associated with the portionof the recorded program that was not played back in real timesubstantially matches the known end time of a second segment,identifying the first segment, the second segment and any segmentsbetween the first and second segments as the portion of the recordedprogram that was not played back in real time.
 14. A method as definedin claim 12 wherein the start times and the end times of the recordinginterval associated with the portion of the recorded program that wasnot played back in real time are normalized to a broadcast duration ofthe recorded program.
 15. A method as defined in claim 11 whereinidentifying the portion of the recorded program that was not played backin real time comprises: comparing the recording interval associated withthe portion of the recorded program that was not played back in realtime to known intervals associated with segments of the recordedprogram; and if the recording interval associated with the portion ofthe recorded program that was not played back in real time overlaps withat least a predetermined amount of at least one of the known intervals,identifying at least one segment associated with the at least one of theknown intervals as the portion of the recorded program that was notplayed back in real time.
 16. A method as defined in claim 15 whereinthe recording interval associated with the portion of the recordedprogram that was not played back in real time is normalized to abroadcast duration of the recorded program.
 17. A method as defined inclaim 1 wherein the recorded program is recorded on a local recordingdevice from a broadcast signal.
 18. A method as defined in claim 17wherein the local recording device comprises at least one of: a digitalvideo recorder, a set top box, a personal video recorder, and an analogvideo recorder.
 19. A method as defined in claim 1 further comprisingstoring at least one of: (a) a channel identifier, (b) a broadcaststation identifier, (c) an input source code, (d) a program identifier,(e) a name of the recorded program, (f) a universal network identifier,(g) a universal program identifier, (h) a digital recording deviceserial number, (i) a tuner identification number, and (j) a playbackmode code in association with the playback time.
 20. A method as definedin claim 1 wherein (a) if a recording interval is zero, then playbackwas paused for a duration of the corresponding playback interval, (b) ifa recording interval has a first sign, then a corresponding portion ofthe recorded program was played at a rate different than real time, and(c) if a recording interval has a second sign opposite the first sign,then a rewind event has occurred.
 21. A method as defined in claim 11wherein if a first portion of the recorded program is identified ashaving been skipped, and a second portion of the recorded program isidentified as having been rewound, comparing the first and secondportions to determine if at least a segment of the first portion wasviewed with the second portion of the recorded program.
 22. A method asdefined in claim 1 further comprising transmitting at least some of therecording times to a collection facility, and wherein comparing playbackintervals between sequential pairs of the playback times withcorresponding recording intervals between sequential pairs of therecording times to determine if a portion of the recorded program wasnot played back in real time is performed at the collection facility.23. A method as defined in claim 22 further comprising transmitting atleast some of the playback times to the collection facility.
 24. Anarticle of manufacture storing machine readable instructions which, whenexecuted, cause a machine to: store a plurality of recording times ofsections of a recorded program in association with playback times of therecorded program; and compare playback intervals between sequentialpairs of the playback times with corresponding recording intervalsbetween sequential pairs of the recording times to determine if anyportion of the recorded program was not played back in real time.
 25. Anarticle of manufacture as defined in claim 24 wherein the plurality ofrecording times substantially correspond to times at which respectivesections of the recorded program are recorded by a local device.
 26. Anarticle of manufacture as defined in claim 24 wherein the machinereadable instructions cause the machine to store the plurality ofrecording times as a plurality of data packets with the recording timesstored in headers of the data packets.
 27. An article of manufacture asdefined in claim 26 wherein the machine readable instruction cause themachine to store each of the recording times in association with atleast one respective packet.
 28. An article of manufacture as defined inclaim 26 wherein the machine readable instructions cause the machine tostore the plurality of recording times of the sections of the recordedprogram in association with the playback times of the recorded programby: retrieving a recording time from a header of a data packet beingplayed back; and storing the recording time in association with one ofthe plurality of playback times.
 29. An article of manufacture asdefined in claim 24 wherein the playback times substantially correspondto times at which respective sections of the recorded program areplayed.
 30. An article of manufacture as defined in claim 24 wherein themachine readable instructions cause the machine to store the pluralityof recording times of the sections of the recorded program inassociation with the playback times of the recorded program by: creatinga plurality of log entry data structures; and storing respective ones ofthe playback times in respective ones of the plurality of log entry datastructures.
 31. An article of manufacture as defined in claim 30 whereinthe machine readable instructions cause the machine to store respectiveones of the plurality of recording times in respective ones of theplurality of log entry data structures.
 32. An article of manufacture asdefined in claim 24 wherein the machine readable instructions cause themachine to store the plurality of recording times of the sections of therecorded program in association with the playback times of the recordedprogram by: creating a plurality of log entry data structures; andstoring respective ones of the recording times in respective ones of theplurality of log entry data structures.
 33. An article of manufacture asdefined in claim 24 wherein, if a playback interval is different than acorresponding one of the recording intervals, then a portion of therecorded program corresponding to the recording interval was not playedback in real time.
 34. An article of manufacture as defined in claim 33wherein the machine readable instructions cause the machine to identifythe portion of the recorded program that was not played back in realtime.
 35. An article of manufacture as defined in claim 34 wherein themachine readable instructions cause the machine to identify the portionof the recorded program that was not played back in real time by:comparing a start time of the recording interval associated with theportion of the recorded program that was not played back in real time toknown start times associated with segments of the recorded program;comparing an end time of the recording interval associated with theportion of the recorded program that was not played back in real time toknown end times associated with segments of the recorded program; and ifthe start time of the recording interval associated with the portion ofthe recorded program that was not played back in real time substantiallymatches the known start time of a first segment, and the end time of therecording interval associated with the portion of the recorded programthat was not played back in real time substantially matches the knownend time of the first segment, identifying the first segment as theportion of the recorded program that was not played back in real time.36. An article of manufacture as defined in claim 35 wherein if thestart time of the recording interval associated with the portion of therecorded program that was not played back in real time substantiallymatches the known start time of the first segment, and the end time ofthe recording interval associated with the portion of the recordedprogram that was not played back in real time substantially matches theknown end time of a second segment, identifying the first segment, thesecond segment and any segments between the first and second segments asthe portion of the recorded program that was not played back in realtime.
 37. An article of manufacture as defined in claim 35 wherein thestart times and the end times of the recording interval associated withthe portion of the recorded program that was not played back in realtime are normalized to a broadcast duration of the recorded program. 38.An article of manufacture as defined in claim 34 wherein the machinereadable instructions cause the machine to identify the portion of therecorded program that was not played back in real time by: comparing therecording interval associated with the portion of the recorded programthat was not played back in real time to known intervals associated withsegments of the recorded program; and if the recording intervalassociated with the portion of the recorded program that was not playedback in real time overlaps with at least a predetermined amount of oneof the known intervals, identifying at least one segment associated withthe at least one of the known intervals as the portion of the recordedprogram that was not played back in real time.
 39. An article ofmanufacture as defined in claim 38 wherein the recording intervalassociated with the portion of the recorded program that was not playedback in real time is normalized to a broadcast duration of the recordedprogram.
 40. An article of manufacture as defined in claim 24 whereinthe recorded program is recorded on a local recording device from abroadcast signal.
 41. An article of manufacture as defined in claim 40wherein the local recording device comprises at least one of: a digitalvideo recorder, a set top box, a personal video recorder, and an analogvideo recorder.
 42. An article of manufacture as defined in claim 24wherein the machine readable instructions cause the machine to store atleast one of: (a) a channel identifier, (b) a broadcast stationidentifier, (c) an input source code, (d) a program identifier, (e) aname of the recorded program, (f) a universal network identifier, (g) auniversal program identifier, (h) a digital recording device serialnumber, (i) a tuner identification number, and (j) a playback mode codein association with the playback time.
 43. An article of manufacture asdefined in claim 24 wherein (a) if a recording interval is zero, thenplayback was paused for a duration of the corresponding playbackinterval, (b) if a recording interval has a first sign, then acorresponding portion of the recorded program was played at a ratedifferent than real time, and (c) if a recording interval has a secondsign opposite the first sign, then a rewind event has occurred.
 44. Anarticle of manufacture as defined in claim 34 wherein if a first portionof the recorded program is identified as having been skipped, and asecond portion of the recorded program is identified as having beenrewound, the machine readable instructions cause the machine to comparethe first and second portions to determine if at least a segment of thefirst portion was viewed with the second portion of the recordedprogram.
 45. An article of manufacture as defined in claim 24 whereinthe machine readable instructions further cause the machine to transmitat least some of the recording times to a collection facility, andwherein the machine readable instructions that cause the machine tocompare playback intervals between sequential pairs of the playbacktimes with corresponding recording intervals between sequential pairs ofthe recording times to determine if a portion of the recorded programwas not played back in real time are executed at a collection facility.46. An article of manufacture as defined in claim 45 wherein the machinereadable instructions further cause the machine to transmit at leastsome of the playback times to the collection facility.
 47. An apparatusto detect portions of a recorded program that were not played back inreal time comprising: a time stamper to record a plurality of recordingtimes in association with a recorded program; a memory to store therecorded program; and a presentation time retriever to retrieve therecording time of a section of the recorded program being played backand to store the retrieved recording time in association with a playbacktime.
 48. An apparatus as defined in claim 47 wherein the playback timeis provided by the time stamper.
 49. An apparatus as defined in claim 47wherein the recorded program is stored as a plurality of packets, andthe time stamper records the recording times in headers of the packets.50. An apparatus as defined in claim 47 further comprising: an intervaldetector to identify recording intervals between successive ones of theplurality of recording times; and a difference detector to determine ifa difference exists between a recording interval and a playbackinterval.
 51. An apparatus as defined in claim 50 further comprising anon-real time content identifier responsive to a detected differencebetween the recording interval and the playback interval to identify aportion of the recorded program that was not played back in real time.52. An apparatus as defined in claim 47 wherein the plurality ofrecording times substantially correspond to times at which respectivesections of the recorded program are recorded by a local device.
 53. Anapparatus as defined in claim 47 wherein the recorded program is storedin the memory as a plurality of data packets, and the recording timesare stored in headers of the data packets.
 54. An apparatus as definedin claim 53 wherein each of the recording times is stored in associationwith at least one respective packet.
 55. An apparatus as defined inclaim 47 wherein the playback time substantially corresponds to a timeat which the section of the recorded program is played.
 56. An apparatusas defined in claim 47 wherein the playback time is stored in a logentry data structure.
 57. An apparatus as defined in claim 57 whereinthe presentation time retriever stores the retrieved recording time in alog entry data structure.
 58. An apparatus as defined in claim 47wherein the presentation time retriever stores the retrieved recordingtime in association with a playback time by storing the retrievedrecording time in a log entry data structure representative of aplayback time.
 59. An apparatus as defined in claim 50 wherein, if thedifference detector detects a difference between a playback interval andone of the recording intervals, then a portion of the recorded programcorresponding to the one of the recording intervals was not played backin real time.
 60. An apparatus as defined in claim 51 wherein thenon-real time content identifier identifies the portion of the recordedprogram that was not played back in real time by: comparing a start timeof the recording interval associated with the portion of the recordedprogram that was not played back in real time to known start timesassociated with segments of the recorded program; comparing an end timeof the recording interval associated with the portion of the recordedprogram that was not played back in real time to known end timesassociated with segments of the recorded program; and if the start timeof the recording interval associated with the portion of the recordedprogram that was not played back in real time substantially matches theknown start time of a first segment, and the end time of the recordinginterval associated with the portion of the recorded program that wasnot played back in real time substantially matches the known end time ofthe first segment, the non-real time content identifier identifies thefirst segment as the portion of the recorded program that was not playedback in real time.
 61. An apparatus as defined in claim 60 wherein ifthe start time of the recording interval associated with the portion ofthe recorded program that was not played back in real time substantiallymatches the known start time of the first segment, and the end time ofthe recording interval associated with the portion of the recordedprogram that was not played back in real time substantially matches theknown end time of a second segment, the non-real time content identifieridentifies the first segment, the second segment and any segmentsbetween the first and second segments as the portion of the recordedprogram that was not played back in real time.
 62. An apparatus asdefined in claim 60 wherein the start times and the end times of therecording interval associated with the portion of the recorded programthat was not played back in real time are normalized to a broadcastduration of the recorded program.
 63. An apparatus as defined in claim51 wherein the non-real time content identifier identifies the portionof the recorded program that was not played back in real time by:comparing the recording interval associated with the portion of therecorded program that was not played back in real time to knownintervals associated with segments of the recorded program; and if therecording interval associated with the portion of the recorded programthat was not played back in real time overlaps with at least apredetermined amount of at least one of the known intervals, identifyingat least one segment associated with the at least one of the knownintervals as the portion that was not played back in real time.
 64. Anapparatus as defined in claim 63 wherein the recording intervalassociated with the portion of the recorded program that was not playedback in real time is normalized to a broadcast duration of the recordedprogram.
 65. An apparatus as defined in claim 47 wherein the recordedprogram is recorded on a local recording device from a broadcast signal.66. An apparatus as defined in claim 65 wherein the local recordingdevice comprises at least one of: a digital video recorder, a set topbox, a personal video recorder, and an analog video recorder.
 67. Anapparatus as defined in claim 47 wherein the presentation time retrieverstores at least one of: (a) a channel identifier, (b) a broadcaststation identifier, (c) an input source code, (d) a program identifier,(e) a name of the recorded program, (f) a universal network identifier,(g) a universal program identifier, (h) a digital recording deviceserial number, (i) a tuner identification number, and (j) a playbackmode code in association with the playback time.
 68. An apparatus asdefined in claim 47 wherein (a) if a recording interval is zero, thenplayback was paused for a duration of the corresponding playbackinterval, (b) if a recording interval has a first sign, then acorresponding portion of the recorded program was played at a ratedifferent than real time, and (c) if a recording interval has a secondsign opposite the first sign, then a rewind event has occurred.
 69. Anapparatus as defined in claim 51 further comprising a recaptureidentifier to determine if a portion of the recorded program that waspassed at a rate greater than real time was viewed in real time as aresult of rewinding the recorded program.
 70. An apparatus as defined inclaim 69 wherein at least one of the time stamper, the memory and thepresentation time retriever are located at a monitored home, and atleast one of the interval detector, the difference detector, thenon-real time content identifier, and the recapture identifier arelocated at at least one of a collection facility and a data loggingdevice.
 71. A method of developing usage data with respect to a recordedprogram comprising: storing recording times in association with recordedsections of the recorded program; playing back at least one of therecorded sections; retrieving the recording time associated with the atleast one of the recorded sections; and recording the retrievedrecording time of the at least one of the recorded sections inassociation with a playback time of the at least one of the recordedsections.
 72. A method of identifying a portion of a recorded programthat was not played in real time comprising: computing a firstdifference between a first recording time and a second recording time;and comparing the first difference to a second difference between afirst playback time and a second playback time to determine if a portionof the recorded program associated with the first difference was playedin real time.
 73. A method as defined in claim 72 further comprisingcomputing the second difference between the first playback time and thesecond playback time.
 74. A method as defined in claim 72 furthercomprising receiving a first data structure containing the firstplayback time and the first recording time.
 75. A method as defined inclaim 74 further comprising receiving a second data structure containingthe second playback time and the second recording time.
 76. A method asdefined in claim 72 wherein, if the second difference is larger than thefirst difference, a portion of the recorded program was at least one ofskipped and fast forwarded.
 77. An apparatus to detect portions of arecorded program that were not played in real time comprising: aninterval detector to compute a recording interval between a firstrecording time and a second recording time; and a difference detector tocompare a playback interval and the recording interval to determine ifthe recording interval is indicative of real time playback of acorresponding portion of the recorded program.
 78. An apparatus asdefined in claim 77 wherein the playback interval is a differencebetween a first playback time and a second playback time.
 79. Anapparatus as defined in claim 78 wherein the playback interval iscomputed by the interval detector.
 80. An apparatus as defined in claim77 further comprising a non-real time content identifier to identify thecorresponding portion of the recorded program that was not played backin real time.
 81. A method for generating a playback information logfile entry, comprising: storing a timestamp in a log file when a storedbroadcast is played back; storing a recording time of the storedbroadcast in the log file; and storing a program identifier in the logfile.
 82. A method as defined in claim 81 wherein the log file stores atleast one of: (a) a broadcast channel number, (b) an input source codefor the stored broadcast, (c) a station name for a station thatbroadcast the stored broadcast, (d) a program name for the storedbroadcast, (e) a universal station identifier for the station thatbroadcast the stored broadcast, (f) a universal network identifier, (g)a universal program identifier, (h) a digital recording device serialnumber, (i) a tuner identification number, and (j) a playback mode codefor the stored broadcast.
 83. An apparatus to identify a portion of arecorded program that was not played in real time comprising: at leastone processor; a memory coupled to the at least one processor andstoring machine readable instructions which, when executed by the atleast one processor, cause the at least one processor to: compute afirst difference between a first recording time and a second recordingtime; and compare the first difference to a second difference between afirst playback time and a second playback time to determine if a portionof the recorded program associated with the first difference was playedin real time.